home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / trueSpace 7.6 / tS761B8Std.exe / {app} / Scripts / D3D / RsD3DMaterialFromME2_Template.fx < prev    next >
Text File  |  2008-06-10  |  27KB  |  756 lines
  1.  
  2. #line 3 "MainD3DShaderTemplate"
  3.  
  4. //----------------------------------------------------------------------
  5. //END - The custom shader code
  6. //----------------------------------------------------------------------
  7.  
  8. //----------------------------------------------------------------------
  9. //Basic shader template + vertex shader (or hw skinning) enabled shadows
  10. //
  11. //Author - Michal Valient
  12. //Copyright (C) 2004-2008 Caligari corporation
  13. //
  14. //----------------------------------------------------------------------
  15.  
  16. /*****
  17. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  18.  
  19. If you make changes here, you have to make sure you modify shadow mapping techique the same way!
  20.  
  21. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  22. *****/
  23.  
  24. uniform float RsD3DMaterialFromME_fNormalMod = 1.0f;
  25. uniform float RsD3DMaterialFromME_fOpacity = 1.0f;
  26.  
  27. uniform float4 RsD3DMaterialFromME_cOverlayMod = { 0.0f, 0.0f, 0.0f, 1.0f };
  28.  
  29.  
  30. #ifdef RsShaderHWSKINNING
  31.     #define SKIN_INDEX_SHIFT 0.001960784313725490196078431372549f
  32.     float4x3 RsD3DMaterialFromME_mSkinMatrices[RTD3DMESH_MAXIMUM_BONE_COUNT];
  33. #endif //RsShaderHWSKINNING
  34.  
  35.  
  36. D3_VERTEXOUTPUT RsD3DMaterialFromME_VertexShader(    in RtFloat4 D3_pInputPosition : POSITION, 
  37.                                                     in RtFloat3 D3_vInputNormal : NORMAL,
  38.                                                     in RtFloat3 D3_vInputTangent : TANGENT,
  39.                                                     in float2   D3_vInputTexCoords1 : TEXCOORD0,
  40.                                                     in float2   D3_vInputTexCoords2 : TEXCOORD1,
  41.                                                     in RtFloat4 D3_cInputColor : COLOR0
  42.  
  43. #ifdef RsShaderHWSKINNING
  44.                                                     , in RtFloat4 D3_vInputBlendIndices : BLENDINDICES
  45.                                                     , in RtFloat4 D3_cInputBlendWeight : BLENDWEIGHT
  46. #endif //RsShaderHWSKINNING
  47.  
  48. )
  49. {
  50.     ///First perform default transformation pipeline
  51.     float3 vCoord1 = 0;
  52.     float3 vCoord2 = 0;
  53.     vCoord1.xy = D3_vInputTexCoords1;
  54.     vCoord2.xy = D3_vInputTexCoords2;
  55.     
  56.     float4 local_vertex_position;
  57.     float3 local_normal;
  58.     float3 local_tangent;
  59.     
  60. #ifdef RsShaderHWSKINNING
  61.  
  62.     float3 tmp_position = 0;
  63.     local_normal = 0.0f;    
  64.     local_tangent = 0.0f;
  65.      
  66.     //Get the blend weights
  67.     float4 blend_weights = (255.0f/127.0f)*D3_cInputBlendWeight - (128.0f / 127.0f);
  68.     float4 blend_indices = D3_vInputBlendIndices * 255.0f + SKIN_INDEX_SHIFT;
  69.     
  70.     /// Skin it!
  71.     for (int bone_idx = 0; bone_idx<4; bone_idx++)
  72.     {
  73.         int matrix_idx            = (int)blend_indices[bone_idx];
  74.         float weight            = blend_weights[bone_idx];
  75.         
  76.         float3 bone_position    = weight*mul(D3_pInputPosition,        RsD3DMaterialFromME_mSkinMatrices[matrix_idx]);
  77.         float3 bone_normal        = weight*mul(D3_vInputNormal,        RsD3DMaterialFromME_mSkinMatrices[matrix_idx]);
  78.         float3 bone_tangent        = weight*mul(D3_vInputTangent,        RsD3DMaterialFromME_mSkinMatrices[matrix_idx]);
  79.         
  80.         tmp_position            += bone_position;
  81.         local_normal            += bone_normal;
  82.         local_tangent            += bone_tangent;
  83.     }
  84.  
  85.     local_vertex_position.xyz = tmp_position.xyz;
  86.     local_vertex_position.w   = 1.0f;
  87.  
  88. #else
  89.  
  90.     local_vertex_position = D3_pInputPosition;
  91.     local_normal = D3_vInputNormal;
  92.     local_tangent = D3_vInputTangent;
  93.  
  94. #endif //RsShaderHWSKINNING
  95.  
  96.     float4 pVertexPosition = mul(local_vertex_position, D3_mObjectToWorld);
  97.     float3 vEyeTmp = D3_pEye - pVertexPosition;
  98.     float  fEyeDist = length(vEyeTmp);
  99.     float3 vEye = normalize(vEyeTmp);
  100.  
  101.     //Flip the normal and tangent direction if we are processing the backface here
  102.     float3 vInputNormal = RsD3DMaterialFromME_fNormalMod * local_normal;
  103.     float3 vInputTangent = RsD3DMaterialFromME_fNormalMod * local_tangent;
  104.  
  105.     float3x3 mToTangentTmp;
  106.     mToTangentTmp[0] = vInputTangent;
  107.     mToTangentTmp[2] = vInputNormal;
  108.     mToTangentTmp[1] = cross(vInputTangent, vInputNormal); //The cross product to compute binormal NxT
  109.     float3x3 mTangentToWorld = mul(mToTangentTmp, D3_mObjectToWorldN);
  110.  
  111.     //------------------------------
  112.     //Perform default processing on variables
  113.     rsxi_VarShaderInput;
  114.  
  115.     tsxi_SetInputTangentToWorld(mTangentToWorld);
  116.     tsxi_SetInputTexCoords1(vCoord1);
  117.     tsxi_SetInputTexCoords2(vCoord2);
  118.     tsxi_SetInputTangent(mTangentToWorld[0]);
  119.     tsxi_SetInputNormal(mTangentToWorld[2]);
  120.     tsxi_SetInputColor(D3_cInputColor);
  121.     tsxi_SetInputAlpha(D3_cInputColor.a);
  122.     tsxi_SetInputPosition(pVertexPosition);
  123.     tsxi_SetInputEyePos(D3_pEye);
  124.     tsxi_SetInputEyeDir(vEye);
  125.     tsxi_SetInputEyeDist(fEyeDist);
  126.     tsxi_SetInputLightDir(vEye);
  127.     tsxi_SetInputLightDist(fEyeDist);
  128.     tsxi_SetInputLightColor(RtFloat4(1,1,1,1));
  129.  
  130. #ifdef RsShaderVSVERTEXSHADER
  131.     RtFloat4 vTmpPos = tsxi_GetInputPosition;
  132.     RtFloat4 vTmpCol = tsxi_GetInputColor;
  133.     RtFloat3 vTmpNorm = tsxi_GetInputNormal;
  134.     RtFloat3 vTmpTang = tsxi_GetInputTangent;
  135.     RsShaderVSVERTEXSHADER(rsxi_SendShaderInput, vTmpPos, vTmpCol, vTmpNorm, vTmpTang);
  136.     tsxi_SetInputPosition(vTmpPos);
  137.     tsxi_SetInputColor(vTmpCol);
  138.     tsxi_SetInputNormal(vTmpNorm);
  139.     tsxi_SetInputTangent(vTmpTang);
  140.     
  141.     //Eye, light and tangent matrices have to be recomputed now
  142.     vEyeTmp = D3_pEye - vTmpPos;
  143.     fEyeDist = length(vEye);
  144.     vEye = normalize(vEyeTmp);
  145.     mTangentToWorld[0] = vTmpTang;
  146.     mTangentToWorld[2] = vTmpNorm;
  147.     mTangentToWorld[1] = cross(vTmpTang, vTmpNorm); //The cross product to compute binormal NxT
  148.  
  149.     tsxi_SetInputEyeDir(vEye);
  150.     tsxi_SetInputEyeDist(fEyeDist);
  151.     tsxi_SetInputLightDir(vEye);
  152.     tsxi_SetInputLightDist(fEyeDist);
  153.     tsxi_SetInputTangentToWorld(mTangentToWorld);
  154. #endif
  155.     
  156. #ifdef RsShaderVSTEXCOORD
  157.     RtFloat3 vTmpTexCrd1 = tsxi_GetInputTexCoords1;
  158.     RtFloat3 vTmpTexCrd2 = tsxi_GetInputTexCoords2;
  159.     RsShaderVSTEXCOORD(rsxi_SendShaderInput, vTmpTexCrd1, vTmpTexCrd2);
  160.     tsxi_SetInputTexCoords1(vTmpTexCrd1);
  161.     tsxi_SetInputTexCoords2(vTmpTexCrd2);
  162. #endif
  163.  
  164. #ifdef RsShaderVSLIGHT
  165.     RtFloat4 vTmpLightColor = tsxi_GetInputLightColor;
  166.     RtFloat3 vTmpLightDir = tsxi_GetInputLightDir;
  167.     RtFloat  vTmpLightDist = tsxi_GetInputLightDist;    
  168.     RsShaderVSLIGHT(rsxi_SendShaderInput, vTmpLightColor, vTmpLightDir, vTmpLightDist);
  169.     tsxi_SetInputLightColor(vTmpLightColor);
  170.     tsxi_SetInputLightDir(normalize(vTmpLightDir));
  171.     tsxi_SetInputLightDist(vTmpLightDist);
  172. #endif
  173.  
  174.     D3_VERTEXOUTPUT Output;
  175.  
  176. #if ((defined(RsShaderVSVERTEXSHADER)) || (defined(RsShaderHWSKINNING)))
  177.     ///If we have vertex shader we need to use world position produced by position shader
  178.     Output.D3_pClipPosition = mul(tsxi_GetInputPosition, D3_mWorldToClip);
  179. #else
  180.     ///Otherwise we use clip position which is faster and more precise.
  181.     Output.D3_pClipPosition = mul(local_vertex_position, D3_mObjectToClip);
  182. #endif
  183.  
  184.     Output.D3_vVertexTexCoords.xy = tsxi_GetInputTexCoords1.xy;
  185.     Output.D3_vVertexTexCoords.wz = tsxi_GetInputTexCoords2.xy;
  186.     Output.D3_pVertexPosition = tsxi_GetInputPosition;
  187.     Output.D3_vEye.xyz = tsxi_GetInputEyeDir;
  188.     Output.D3_vEye.w = tsxi_GetInputEyeDist;
  189.     Output.D3_mToWorld = tsxi_GetInputTangentToWorld;
  190.     Output.D3_vLightVector.xyz = tsxi_GetInputLightDir;
  191.     Output.D3_vLightVector.w = tsxi_GetInputLightDist;
  192.     Output.D3_cLightColor = tsxi_GetInputLightColor;
  193.     Output.D3_cVertexColor = tsxi_GetInputColor;
  194.  
  195.     return Output;
  196. }
  197.  
  198. D3_PIXELOUTPUT RsD3DMaterialFromME_PixelShader(uniform bool IsFirstPass,
  199.                                                in D3_PIXELINPUT Input)
  200. {
  201.     D3_PIXELOUTPUT Output;
  202.  
  203.     rsxi_VarShaderInput;
  204.  
  205.     //------------------------------
  206.     //Perform default processing on variables
  207.     tsxi_SetInputTangentToWorld(Input.D3_mToWorld);
  208.     tsxi_SetInputTexCoords1(Input.D3_vVertexTexCoords.xyzw);
  209.     tsxi_SetInputTexCoords2(Input.D3_vVertexTexCoords.wzyx);
  210.     tsxi_SetInputTangent(Input.D3_mToWorld[0]);
  211.     tsxi_SetInputNormal(Input.D3_mToWorld[2]);
  212.     tsxi_SetInputColor(Input.D3_cVertexColor);
  213.     tsxi_SetInputAlpha(Input.D3_cVertexColor.a);
  214.     tsxi_SetInputPosition(Input.D3_pVertexPosition);
  215.     tsxi_SetInputEyePos(D3_pEye);
  216.     tsxi_SetInputEyeDist(Input.D3_vEye.w);
  217.     tsxi_SetInputEyeDir(rtx_CubeNormalize(Input.D3_vEye.xyz));
  218.     tsxi_SetInputLightDist(Input.D3_vLightVector.w);
  219.     tsxi_SetInputLightDir(Input.D3_vLightVector.xyz);
  220.     tsxi_SetInputLightColor(Input.D3_cLightColor);
  221.  
  222. #ifdef RsShaderNORMAL
  223.     RtFloat3 vTmpNormal = tsxi_GetInputNormal;
  224.     RtFloat3 vTmpTangent = tsxi_GetInputTangent;
  225.     RsShaderNORMAL(rsxi_SendShaderInput, vTmpNormal, vTmpTangent);
  226.     tsxi_SetInputNormal(normalize(vTmpNormal));
  227.     tsxi_SetInputTangent(rtx_CubeNormalize(vTmpTangent));
  228. #else
  229.     tsxi_SetInputNormal(rtx_CubeNormalize(tsxi_GetInputNormal));
  230.     tsxi_SetInputTangent(rtx_CubeNormalize(tsxi_GetInputTangent));
  231. #endif
  232.  
  233. #ifdef RsShaderALPHA
  234.     RtFloat fTmpAlpha = tsxi_GetInputAlpha;
  235.     RsShaderALPHA(rsxi_SendShaderInput, fTmpAlpha);
  236.     tsxi_SetInputAlpha(fTmpAlpha);
  237. #endif
  238.  
  239. #ifdef RsShaderCOLOR
  240.     RtFloat4 vTmpColor = tsxi_GetInputColor;
  241.     RsShaderCOLOR(rsxi_SendShaderInput, vTmpColor);
  242.     tsxi_SetInputColor(vTmpColor);
  243. #endif
  244.  
  245. #ifdef RsShaderLIGHT
  246.     RtFloat4 vTmpLightColor = tsxi_GetInputLightColor;
  247.     RtFloat3 vTmpLightDir = tsxi_GetInputLightDir;
  248.     RtFloat  fTmpLightDist = tsxi_GetInputLightDist;
  249.     RsShaderLIGHT(rsxi_SendShaderInput, vTmpLightColor, vTmpLightDir, fTmpLightDist);
  250.     tsxi_SetInputLightColor(vTmpLightColor);
  251.     tsxi_SetInputLightDist(fTmpLightDist);
  252.     tsxi_SetInputLightDir(rtx_CubeNormalize(vTmpLightDir));
  253. #else
  254.     RtFloat3 vTmpLightDir = tsxi_GetInputLightDir;
  255.     tsxi_SetInputLightDir(rtx_CubeNormalize(vTmpLightDir));
  256. #endif
  257.  
  258.     RtFloat4 vTmpOutColor = tsxi_GetInputColor;
  259.  
  260. #ifdef RsShaderMODEL
  261.     RsShaderMODEL(rsxi_SendShaderInput, vTmpOutColor);
  262. #else
  263.     vTmpOutColor.xyz = tsxi_GetInputColor * tsxi_GetInputLightColor * saturate(dot(tsxi_GetInputLightDir, tsxi_GetInputNormal));
  264. #endif
  265.  
  266. #ifdef RsShaderCONSTANT
  267.     if (IsFirstPass)
  268.     {
  269.         RtFloat4 vTmpConstantColor = 0.0f;
  270.         RsShaderCONSTANT(rsxi_SendShaderInput, vTmpConstantColor);
  271.         vTmpOutColor.xyz += vTmpConstantColor;        /// Append the constant color if available
  272.     }
  273. #endif
  274.  
  275.     ///Add the overlay color
  276.     if (IsFirstPass)
  277.     {
  278.         ///First pass performs complete blending.
  279.         vTmpOutColor.xyz = RsD3DMaterialFromME_cOverlayMod.xyz + RsD3DMaterialFromME_cOverlayMod.a * vTmpOutColor.xyz;
  280.     }
  281.     else
  282.     {
  283.         ///All other passes just attenuate the lighting accordingly.
  284.         vTmpOutColor.xyz = RsD3DMaterialFromME_cOverlayMod.a * vTmpOutColor.xyz;
  285.     }
  286.  
  287. #ifdef RsShaderALPHA
  288.     vTmpOutColor.a = saturate(vTmpOutColor.a * RsD3DMaterialFromME_fOpacity);
  289. #else
  290.     vTmpOutColor.a = saturate(RsD3DMaterialFromME_fOpacity);
  291. #endif
  292.  
  293.     Output.D3_cOutColor = vTmpOutColor;
  294.  
  295.     return Output;
  296. }
  297.  
  298. pixelshader RsD3DMaterialFromME_PixelShader_ps_2_0_P1 =            compile ME_PS_PROFILE RsD3DMaterialFromME_PixelShader(true);
  299. pixelshader RsD3DMaterialFromME_PixelShader_ps_2_0_P2 =            compile ME_PS_PROFILE RsD3DMaterialFromME_PixelShader(false);
  300. pixelshader RsD3DMaterialFromME_PixelShader_ps_2_0_Opaque_P1 =    compile ME_PS_PROFILE RsD3DMaterialFromME_PixelShader(true);
  301. pixelshader RsD3DMaterialFromME_PixelShader_ps_2_0_Opaque_P2 =    compile ME_PS_PROFILE RsD3DMaterialFromME_PixelShader(false);
  302. vertexshader RsD3DMaterialFromME_VertexShader_vs_2_0 =            compile ME_VS_PROFILE RsD3DMaterialFromME_VertexShader();
  303.  
  304. //------------------------------
  305. // Techniques
  306. // This is automatically generated code
  307. //------------------------------
  308. //
  309. technique D3_MAIN_TECHNIQUE_OPAQUE
  310. <
  311.     string Rs_TechniqueMode = "firstlight";
  312.     string Rs_TechniqueOpacity = "opaque";
  313.     string Rs_TechniqueQuality = "95";
  314. >
  315. {
  316.     pass D3_PASS_01
  317.     {
  318.         VertexShader = (RsD3DMaterialFromME_VertexShader_vs_2_0);
  319.         PixelShader = (RsD3DMaterialFromME_PixelShader_ps_2_0_Opaque_P1);
  320.  
  321.         AlphaBlendEnable = false;
  322.         ZEnable = true;
  323.         ZFunc = LESSEQUAL;
  324.         ZWriteEnable = true;
  325.         CullMode = CCW;
  326.     }
  327. }
  328.  
  329. technique D3_MAIN_TECHNIQUE_OPAQUE_MOREPASSES
  330. <
  331.     string Rs_TechniqueMode = "morelights";
  332.     string Rs_TechniqueOpacity = "opaque";
  333.     string Rs_TechniqueQuality = "95";
  334. >
  335. {
  336.     pass D3_PASS_01
  337.     {
  338.         VertexShader = (RsD3DMaterialFromME_VertexShader_vs_2_0);
  339.         PixelShader = (RsD3DMaterialFromME_PixelShader_ps_2_0_Opaque_P2);
  340.  
  341.         AlphaBlendEnable = true;
  342.         SrcBlend = ONE;
  343.         DestBlend = ONE;
  344.         
  345.         ZEnable = true;
  346.         ZFunc = LESSEQUAL;
  347.         ZWriteEnable = false;
  348.  
  349.         CullMode = CCW;
  350.     }
  351. }
  352.  
  353. technique D3_MAIN_TECHNIQUE
  354. <
  355.     string Rs_TechniqueMode = "firstlight";
  356.     string Rs_TechniqueOpacity = "transparent";
  357.     string Rs_TechniqueQuality = "95";
  358. >
  359. {
  360.     pass D3_PASS_01
  361.     {
  362.         VertexShader = (RsD3DMaterialFromME_VertexShader_vs_2_0);
  363.         PixelShader = (RsD3DMaterialFromME_PixelShader_ps_2_0_P1);
  364.  
  365.         AlphaBlendEnable = true;
  366.         SrcBlend = SRCALPHA;
  367.         DestBlend = INVSRCALPHA;
  368.  
  369.         ZEnable = true;
  370.         ZFunc = LESSEQUAL;
  371.         ZWriteEnable = false;
  372.     }
  373. }
  374.  
  375. technique D3_MAIN_TECHNIQUE_MOREPASSES
  376. <
  377.     string Rs_TechniqueMode = "morelights";
  378.     string Rs_TechniqueOpacity = "transparent";
  379.     string Rs_TechniqueQuality = "95";
  380. >
  381. {
  382.     pass D3_PASS_01
  383.     {
  384.         VertexShader = (RsD3DMaterialFromME_VertexShader_vs_2_0);
  385.         PixelShader = (RsD3DMaterialFromME_PixelShader_ps_2_0_P2);
  386.  
  387.         AlphaBlendEnable = true;
  388.         SrcBlend = SRCALPHA;
  389.         DestBlend = ONE;
  390.  
  391.         ZEnable = true;
  392.         ZFunc = LESSEQUAL;
  393.         ZWriteEnable = false;
  394.     }
  395. }
  396.  
  397.  
  398. //----------------------------------------------------------------------
  399. //----------------------------------------------------------------------
  400. //----------------------------------------------------------------------
  401. // Shadow mapping support
  402. //----------------------------------------------------------------------
  403. //----------------------------------------------------------------------
  404. //----------------------------------------------------------------------
  405.  
  406. ///Shadow uniforms - keep in sync with RsD3DShadowMapRT2.fx
  407. uniform float    fShadowBias;
  408. uniform float    fKillThresholdValue;
  409.  
  410. //structures
  411. typedef struct 
  412. {
  413.     RtFloat4    D3_pInputPosition   :   POSITION;
  414.     RtFloat3    D3_vInputNormal     :   NORMAL;
  415.     RtFloat3    D3_vInputTangent    :   TANGENT;
  416.     float2      D3_vInputTexCoords1 :   TEXCOORD0;
  417.     float2      D3_vInputTexCoords2 :   TEXCOORD1;
  418.     RtFloat4    D3_cInputColor      :   COLOR0;
  419. } D3_SHADOW_VERTEXINPUT;
  420.  
  421. typedef struct 
  422. {
  423.     RtFloat4    D3_pClipPosition    :   POSITION;
  424.     RtFloat4    D3_vVertexTexCoords :   TEXCOORD0;
  425.     RtFloat4    D3_pVertexPosition  :   TEXCOORD1;
  426.     RtFloat3x3  D3_mToWorld         :   TEXCOORD2;
  427.     RtFloat4    D3_vEye                :   TEXCOORD5;
  428.     RtFloat4    D3_pClipPosition2   :   TEXCOORD6;
  429.     RtFloat4    D3_cVertexColor     :   COLOR0;
  430. } D3_SHADOW_VERTEXOUTPUT;
  431.  
  432. typedef struct {
  433.     RtFloat4    D3_vVertexTexCoords :   TEXCOORD0;
  434.     RtFloat4    D3_pVertexPosition  :   TEXCOORD1;
  435.     RtFloat3x3  D3_mToWorld         :   TEXCOORD2;
  436.     RtFloat4    D3_vEye                :   TEXCOORD5;
  437.     RtFloat4    D3_pClipPosition2   :   TEXCOORD6;
  438.     RtFloat4    D3_cVertexColor     :   COLOR0;
  439. } D3_SHADOW_PIXELINPUT;
  440.  
  441. typedef struct {
  442.     float4  D3_cOutColor        :   COLOR0;
  443. } D3_SHADOW_PIXELOUTPUT;
  444.  
  445. D3_SHADOW_VERTEXOUTPUT RsD3DMaterialFromME_Shadow_VertexShader(    in RtFloat4 D3_pInputPosition : POSITION, 
  446.                                                                 in RtFloat3 D3_vInputNormal : NORMAL,
  447.                                                                 in RtFloat3 D3_vInputTangent : TANGENT,
  448.                                                                 in float2   D3_vInputTexCoords1 : TEXCOORD0,
  449.                                                                 in float2   D3_vInputTexCoords2 : TEXCOORD1,
  450.                                                                 in RtFloat4 D3_cInputColor : COLOR0
  451.  
  452. #ifdef RsShaderHWSKINNING
  453.                                                                 , in RtFloat4 D3_vInputBlendIndices : BLENDINDICES
  454.                                                                 , in RtFloat4 D3_cInputBlendWeight : BLENDWEIGHT
  455. #endif //RsShaderHWSKINNING
  456.  
  457. )
  458. {
  459.     ///First perform default transformation pipeline
  460.     float3 vCoord1 = 0;
  461.     float3 vCoord2 = 0;
  462.     vCoord1.xy = D3_vInputTexCoords1;
  463.     vCoord2.xy = D3_vInputTexCoords2;
  464.  
  465.     float4 local_vertex_position;
  466.     float3 local_normal;
  467.     float3 local_tangent;
  468.     
  469. #ifdef RsShaderHWSKINNING
  470.  
  471.     float3 tmp_position = 0;
  472.     local_normal = 0.0f;    
  473.     local_tangent = 0.0f;
  474.      
  475.     //Get the blend weights
  476.     float4 blend_weights = (255.0f/127.0f)*D3_cInputBlendWeight - (128.0f / 127.0f);
  477.     float4 blend_indices = D3_vInputBlendIndices * 255.0f + SKIN_INDEX_SHIFT;
  478.     
  479.     /// Skin it!
  480.     for (int bone_idx = 0; bone_idx<4; bone_idx++)
  481.     {
  482.         int matrix_idx            = (int)blend_indices[bone_idx];
  483.         float weight            = blend_weights[bone_idx];
  484.         
  485.         float3 bone_position    = weight*mul(D3_pInputPosition,        RsD3DMaterialFromME_mSkinMatrices[matrix_idx]);
  486.         float3 bone_normal        = weight*mul(D3_vInputNormal,        RsD3DMaterialFromME_mSkinMatrices[matrix_idx]);
  487.         float3 bone_tangent        = weight*mul(D3_vInputTangent,        RsD3DMaterialFromME_mSkinMatrices[matrix_idx]);
  488.         
  489.         tmp_position            += bone_position;
  490.         local_normal            += bone_normal;
  491.         local_tangent            += bone_tangent;
  492.     }
  493.  
  494.     local_vertex_position.xyz = tmp_position.xyz;
  495.     local_vertex_position.w   = 1.0f;
  496.  
  497. #else
  498.  
  499.     local_vertex_position = D3_pInputPosition;
  500.     local_normal = D3_vInputNormal;
  501.     local_tangent = D3_vInputTangent;
  502.  
  503. #endif //RsShaderHWSKINNING
  504.  
  505.     float4 pVertexPosition = mul(local_vertex_position, D3_mObjectToWorld);
  506.     float3 vEyeTmp = D3_pEye - pVertexPosition;
  507.     float  fEyeDist = length(vEyeTmp);
  508.     float3 vEye = normalize(vEyeTmp);
  509.  
  510.     //Flip the normal and tangent direction if we are processing the backface here
  511.     float3 vInputNormal = RsD3DMaterialFromME_fNormalMod * local_normal;
  512.     float3 vInputTangent = RsD3DMaterialFromME_fNormalMod * local_tangent;
  513.  
  514.     float3x3 mToTangentTmp;
  515.     mToTangentTmp[0] = vInputTangent;
  516.     mToTangentTmp[2] = vInputNormal;
  517.     mToTangentTmp[1] = cross(vInputTangent, vInputNormal); //The cross product to compute binormal NxT
  518.     float3x3 mTangentToWorld = mul(mToTangentTmp, D3_mObjectToWorldN);
  519.  
  520.     //------------------------------
  521.     //Perform default processing on variables
  522.     rsxi_VarShaderInput;
  523.  
  524.     tsxi_SetInputTangentToWorld(mTangentToWorld);
  525.     tsxi_SetInputTexCoords1(vCoord1);
  526.     tsxi_SetInputTexCoords2(vCoord2);
  527.     tsxi_SetInputTangent(mTangentToWorld[0]);
  528.     tsxi_SetInputNormal(mTangentToWorld[2]);
  529.     tsxi_SetInputColor(D3_cInputColor);
  530.     tsxi_SetInputAlpha(D3_cInputColor.a);
  531.     tsxi_SetInputPosition(pVertexPosition);
  532.     tsxi_SetInputEyePos(D3_pEye);
  533.     tsxi_SetInputEyeDir(vEye);
  534.     tsxi_SetInputEyeDist(fEyeDist);
  535.     tsxi_SetInputLightDir(vEye);
  536.     tsxi_SetInputLightDist(fEyeDist);
  537.     tsxi_SetInputLightColor(RtFloat4(1,1,1,1));
  538.  
  539. #ifdef RsShaderVSVERTEXSHADER
  540.     RtFloat4 vTmpPos = tsxi_GetInputPosition;
  541.     RtFloat4 vTmpCol = tsxi_GetInputColor;
  542.     RtFloat3 vTmpNorm = tsxi_GetInputNormal;
  543.     RtFloat3 vTmpTang = tsxi_GetInputTangent;
  544.     RsShaderVSVERTEXSHADER(rsxi_SendShaderInput, vTmpPos, vTmpCol, vTmpNorm, vTmpTang);
  545.     tsxi_SetInputPosition(vTmpPos);
  546.     tsxi_SetInputColor(vTmpCol);
  547.     tsxi_SetInputNormal(vTmpNorm);
  548.     tsxi_SetInputTangent(vTmpTang);
  549.     
  550.     //Eye, light and tangent matrices have to be recomputed now
  551.     vEyeTmp = D3_pEye - vTmpPos;
  552.     fEyeDist = length(vEye);
  553.     vEye = normalize(vEyeTmp);
  554.     mTangentToWorld[0] = vTmpTang;
  555.     mTangentToWorld[2] = vTmpNorm;
  556.     mTangentToWorld[1] = cross(vTmpTang, vTmpNorm); //The cross product to compute binormal NxT
  557.  
  558.     tsxi_SetInputEyeDir(vEye);
  559.     tsxi_SetInputEyeDist(fEyeDist);
  560.     tsxi_SetInputLightDir(vEye);
  561.     tsxi_SetInputLightDist(fEyeDist);
  562.     tsxi_SetInputTangentToWorld(mTangentToWorld);
  563. #endif
  564.     
  565. #ifdef RsShaderVSTEXCOORD
  566.     RtFloat3 vTmpTexCrd1 = tsxi_GetInputTexCoords1;
  567.     RtFloat3 vTmpTexCrd2 = tsxi_GetInputTexCoords2;
  568.     RsShaderVSTEXCOORD(rsxi_SendShaderInput, vTmpTexCrd1, vTmpTexCrd2);
  569.     tsxi_SetInputTexCoords1(vTmpTexCrd1);
  570.     tsxi_SetInputTexCoords2(vTmpTexCrd2);
  571. #endif
  572.  
  573.     D3_SHADOW_VERTEXOUTPUT Output;
  574.  
  575. #if ((defined(RsShaderVSVERTEXSHADER)) || (defined(RsShaderHWSKINNING)))
  576.     ///If we have vertex shader we need to use world position produced by position shader
  577.     Output.D3_pClipPosition = mul(tsxi_GetInputPosition, D3_mWorldToClip);
  578. #else
  579.     ///Otherwise we use clip position which is faster and more precise.
  580.     Output.D3_pClipPosition = mul(local_vertex_position, D3_mObjectToClip);
  581. #endif
  582.     Output.D3_pClipPosition2 = Output.D3_pClipPosition;
  583.     Output.D3_vVertexTexCoords.xy = tsxi_GetInputTexCoords1.xy;
  584.     Output.D3_vVertexTexCoords.wz = tsxi_GetInputTexCoords2.xy;
  585.     Output.D3_pVertexPosition = tsxi_GetInputPosition;
  586.     Output.D3_vEye.xyz = tsxi_GetInputEyeDir;
  587.     Output.D3_vEye.w = tsxi_GetInputEyeDist;
  588.     Output.D3_mToWorld = tsxi_GetInputTangentToWorld;
  589.     Output.D3_cVertexColor = tsxi_GetInputColor;
  590.     return Output;
  591. }
  592.  
  593. #define SHADOW_QUALITY_LQ  1
  594. #define SHADOW_QUALITY_MQ  2
  595. #define SHADOW_QUALITY_HQ  3
  596.  
  597. D3_SHADOW_PIXELOUTPUT RsD3DMaterialFromME_Shadow_PixelShader(uniform int inShadowQuality, 
  598.                                                              in D3_SHADOW_PIXELINPUT Input)
  599. {
  600.     D3_SHADOW_PIXELOUTPUT Output;
  601.  
  602.     rsxi_VarShaderInput;
  603.  
  604.     //------------------------------
  605.     //Perform default processing on variables
  606.     tsxi_SetInputTangentToWorld(Input.D3_mToWorld);
  607.     tsxi_SetInputTexCoords1(Input.D3_vVertexTexCoords.xyzw);
  608.     tsxi_SetInputTexCoords2(Input.D3_vVertexTexCoords.wzyx);
  609.     tsxi_SetInputTangent(Input.D3_mToWorld[0]);
  610.     tsxi_SetInputNormal(Input.D3_mToWorld[2]);
  611.     tsxi_SetInputColor(Input.D3_cVertexColor);
  612.     tsxi_SetInputAlpha(Input.D3_cVertexColor.a);
  613.     tsxi_SetInputPosition(Input.D3_pVertexPosition);
  614.     tsxi_SetInputEyePos(D3_pEye);
  615.     tsxi_SetInputEyeDist(Input.D3_vEye.w);
  616.     tsxi_SetInputEyeDir(rtx_CubeNormalize(Input.D3_vEye.xyz));
  617.     tsxi_SetInputLightDist(tsxi_GetInputEyeDist);
  618.     tsxi_SetInputLightDir(tsxi_GetInputEyeDir);
  619.     tsxi_SetInputLightColor(RtFloat4(1,1,1,1));
  620.  
  621. #ifdef RsShaderNORMAL
  622.     RtFloat3 vTmpNormal = tsxi_GetInputNormal;
  623.     RtFloat3 vTmpTangent = tsxi_GetInputTangent;
  624.     RsShaderNORMAL(rsxi_SendShaderInput, vTmpNormal, vTmpTangent);
  625.     tsxi_SetInputNormal(normalize(vTmpNormal));
  626.     tsxi_SetInputTangent(rtx_CubeNormalize(vTmpTangent));
  627. #else
  628.     tsxi_SetInputNormal(rtx_CubeNormalize(tsxi_GetInputNormal));
  629.     tsxi_SetInputTangent(rtx_CubeNormalize(tsxi_GetInputTangent));
  630. #endif
  631.  
  632. #ifdef RsShaderALPHA
  633.     RtFloat fTmpAlpha = tsxi_GetInputAlpha;
  634.     RsShaderALPHA(rsxi_SendShaderInput, fTmpAlpha);
  635.     tsxi_SetInputAlpha(fTmpAlpha);
  636. #endif
  637.  
  638. #ifdef RsShaderCOLOR
  639.     RtFloat4 vTmpColor = tsxi_GetInputColor;
  640.     RsShaderCOLOR(rsxi_SendShaderInput, vTmpColor);
  641.     tsxi_SetInputColor(vTmpColor);
  642. #endif
  643.  
  644.     RtFloat4 vTmpOutColor = tsxi_GetInputColor;
  645.  
  646. #ifdef RsShaderMODEL
  647.     RsShaderMODEL(rsxi_SendShaderInput, vTmpOutColor);
  648. #else
  649.     vTmpOutColor.xyz = tsxi_GetInputColor * tsxi_GetInputLightColor * saturate(dot(tsxi_GetInputLightDir, tsxi_GetInputNormal));
  650. #endif
  651.  
  652.     ///We override the color portion here to be used by shadows
  653.     float4 output_depth = 0.0f;
  654.     if (inShadowQuality == SHADOW_QUALITY_MQ)
  655.     {
  656.         output_depth = Input.D3_pClipPosition2.z / Input.D3_pClipPosition2.w + fShadowBias;
  657.  
  658.         ///If we do MQ shadows then we most probably don't have alpha channel and most probably also no alpha test.
  659.         ///Therefore we have to kill the pixels manually
  660.         clip(vTmpOutColor.a - fKillThresholdValue);
  661.     }
  662.     else if (inShadowQuality == SHADOW_QUALITY_LQ)
  663.     {
  664.         float4 vRet;
  665.         float fVal = Input.D3_pClipPosition2.z / Input.D3_pClipPosition2.w + fShadowBias;
  666.         vRet.x = fVal * 255.0f;
  667.         vRet.y = (vRet.x - floor(vRet.x)) * 255.0f;
  668.         vRet.z = (vRet.y - floor(vRet.y)) * 255.0f;
  669.         vRet.w = (vRet.z - floor(vRet.z)) * 255.0f;
  670.         vRet = floor(vRet) / 255.0f;
  671.  
  672.         output_depth = vRet;
  673.     }
  674.     
  675.     vTmpOutColor.xyz = output_depth.xyz;
  676.  
  677.     Output.D3_cOutColor = vTmpOutColor;
  678.     return Output;
  679. }
  680.  
  681. pixelshader  RsD3DMaterialFromME_Shadow_PixelShader_ps_2_0_LQ =            compile ME_PS_PROFILE RsD3DMaterialFromME_Shadow_PixelShader(SHADOW_QUALITY_LQ);
  682. pixelshader  RsD3DMaterialFromME_Shadow_PixelShader_ps_2_0_MQ =            compile ME_PS_PROFILE RsD3DMaterialFromME_Shadow_PixelShader(SHADOW_QUALITY_MQ);
  683. pixelshader  RsD3DMaterialFromME_Shadow_PixelShader_ps_2_0_HQ =            compile ME_PS_PROFILE RsD3DMaterialFromME_Shadow_PixelShader(SHADOW_QUALITY_HQ);
  684. vertexshader RsD3DMaterialFromME_Shadow_VertexShader_vs_2_0 =            compile ME_VS_PROFILE RsD3DMaterialFromME_Shadow_VertexShader();
  685.  
  686. //------------------------------
  687. // Shadow Techniques
  688. //------------------------------
  689. //
  690. technique T_ShadowMapHardware
  691. <
  692.     string Rs_TechniqueMode = "shadow_hq";
  693.     string Rs_TechniqueOpacity = "opaque";
  694.     string Rs_TechniqueQuality = "100";
  695. >
  696. {
  697.     pass P0
  698.     {
  699.         VertexShader = (RsD3DMaterialFromME_Shadow_VertexShader_vs_2_0);
  700.         PixelShader = (RsD3DMaterialFromME_Shadow_PixelShader_ps_2_0_HQ);
  701.  
  702.         AlphaBlendEnable = false;
  703.  
  704.         ZEnable = true;
  705.         ZFunc = LESSEQUAL;
  706.         ZWriteEnable = true;
  707.         
  708.         Cullmode = NONE;
  709.     }
  710. }
  711.  
  712. technique T_ShadowMapMQ 
  713. <
  714.     string Rs_TechniqueMode = "shadow_mq";
  715.     string Rs_TechniqueOpacity = "opaque";
  716.     string Rs_TechniqueQuality = "75";
  717. >
  718. {
  719.     pass P0
  720.     {
  721.         VertexShader = (RsD3DMaterialFromME_Shadow_VertexShader_vs_2_0);
  722.         PixelShader = (RsD3DMaterialFromME_Shadow_PixelShader_ps_2_0_MQ);
  723.  
  724.         AlphaBlendEnable = false;
  725.  
  726.         ZEnable = true;
  727.         ZFunc = LESSEQUAL;
  728.         ZWriteEnable = true;
  729.  
  730.         Cullmode = NONE;
  731.     }
  732. }
  733.  
  734. technique T_ShadowMapRGBA8 
  735. <
  736.     string Rs_TechniqueMode = "shadow_lq";
  737.     string Rs_TechniqueOpacity = "opaque";
  738.     string Rs_TechniqueQuality = "50";
  739. >
  740. {
  741.     pass P0
  742.     {
  743.         VertexShader = (RsD3DMaterialFromME_Shadow_VertexShader_vs_2_0);
  744.         PixelShader = (RsD3DMaterialFromME_Shadow_PixelShader_ps_2_0_LQ);
  745.  
  746.         AlphaBlendEnable = false;
  747.  
  748.         ZEnable = true;
  749.         ZFunc = LESSEQUAL;
  750.         ZWriteEnable = true;
  751.  
  752.         Cullmode = NONE;
  753.     }
  754. }
  755.  
  756.